System and method for binary persistence format for a recognition result lattice

ABSTRACT

A system and method for storing document data in a serialized binary format recognition lattice structure so that the data is accessible to other applications. The lattice structure is generated that includes root node data. Child nodes correspond to columns of the recognition lattice. Each node includes a descriptor that is a collection of flags indicating presence of specific components of the node. The child nodes may include grandchild nodes with similar structure corresponding to elements within the columns. Each node further includes property information associated with the node. The recognition lattice is stored in a serial binary data format.

RELATED APPLICATIONS

This application claims is a continuation of application Ser. No.11/112,697, filed Apr. 21, 2005, the benefit of the earlier filing dateis hereby claimed under 35 U.S.C. §120.

BACKGROUND OF THE INVENTION

Tablet PCs typically allow a user to draw or write directly on thescreen. This drawing or writing is generally referred to as “inking.”Inking is a type of user input and may include a touch screen and a userengaging a computing pen and writing on a screen as if writing with atraditional pen and paper. Inking is used with a wide variety ofapplications. For example, inking may be used in drawing applications,painting applications, word processing applications, credit cardsignature applications, and the like.

Inking may include more than just a visual representation of penstrokes; it may include a data type. While data structures are known,the size of the data structure used to store information may becomeexcessively large and cumbersome. Also, document structure compatibilitybetween programs increases efficiency and general usability of thecomputer. Compatibility, however, may be an issue where a user desiresto transfer ink data from one application to another ink application.

An analyzer application may analyze strokes of handwriting and provide adocument structure corresponding to the strokes. The document structureof the analysis may include a tree representation of the strokes. Forexample, the tree may contain paragraph, line and word information. Therichness of the tree may increase as the complexity of the ink documentincreases.

SUMMARY OF THE INVENTION

Aspects of the present invention relate to a system and method forproviding a binary persistence format for a recognition result lattice.Recognition results, usually from an ink analyzer application or anyapplication that uses recognizers to recognize digital ink data, arestructured in a lattice format that enables efficient storage and accessof recognition results such as top element, recognized string, strokenumbers, possible combinations, properties of recognized elements, andthe like. Due to large amount of data associated with recognitionresults, the lattice is arranged to store units of recognition resultsbased on a hierarchical tree structure. Each unit includes informationassociated with recognition content, properties, relationship to otherunits, and the like. The lattice structure is then serialized into abinary persistence format for further processing and sharing between twoapplications.

In accordance with one aspect, a method is provided whereby a first datafield is generated for storing size data associated with the entireserialized recognition data. The method further includes generating asecond data field for storing lattice descriptor data. The latticedescriptor data is a combination of flags that indicate thecharacteristic of the recognition data as saved in the latticestructure. A third data field is then generated which stores the actualserialized data for the recognition lattice, referred henceforth as RootNode Data. The root node data includes information associated withcolumn count of the lattice structure. Additional data fields are alsogenerated for storing child node data based on the column count of thelattice structure. Each additional data field includes informationassociated with a column of the lattice structure.

According to a further aspect, the method may also include generatingfurther data fields for storing grandchild node data based on elementsof each column. The further data fields are structured within theadditional data fields such that the elements of each column areassociated with that column.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates a computing device that may be used according to anexample embodiment.

FIG. 2 illustrates a functional block diagram of an example recognitionplatform.

FIG. 3 illustrates an example parsing of text for a lattice structureaccording to another example embodiment.

FIG. 4A is a diagram illustrating an example numbering of strokes ofhandwriting.

FIG. 4B is a diagram illustrating example lattice columns based on thenumbering of the strokes of FIG. 4A and possible combinations includinga top string and alternate strings according to an embodiment.

FIG. 5 is a diagram illustrating an example recognition latticestructured according to one embodiment of binary persistence format.

FIG. 6 is a logic flow diagram illustrating a process for storingrecognition data in a lattice.

DETAILED DESCRIPTION

Embodiments of the present invention now will be described more fullyhereinafter with reference to the accompanying drawings, which form apart hereof, and which show, by way of illustration, specific exemplaryembodiments for practicing the invention. This invention may, however,be embodied in many different forms and should not be construed aslimited to the embodiments set forth herein; rather, these embodimentsare provided so that this disclosure will be thorough and complete, andwill fully convey the scope of the invention to those skilled in theart. Among other things, the present invention may be embodied asmethods or devices. Accordingly, the present invention may take the formof an entirely hardware embodiment, an entirely software embodiment oran embodiment combining software and hardware aspects. The followingdetailed description is, therefore, not to be taken in a limiting sense.

Illustrative Operating Environment

Referring to FIG. 1, an example system for implementing the inventionincludes a computing device, such as computing device 100. In a basicconfiguration, computing device 100 typically includes at least oneprocessing unit 102 and system memory 104. Depending on the exactconfiguration and type of computing device, system memory 104 may bevolatile (such as RAM), non-volatile (such as ROM, flash memory, and thelike) or some combination of the two. System memory 104 typicallyincludes an operating system 105, one or more applications 106, and mayinclude program data 107. This basic configuration is illustrated inFIG. 1 by those components within dashed line 108.

Computing device 100 may also have additional features or functionality.For example, computing device 100 may also include additional datastorage devices (removable and/or non-removable) such as, for example,magnetic disks, optical disks, or tape. Such additional storage isillustrated in FIG. 1 by removable storage 109 and non-removable storage110. Computer storage media may include volatile and non-volatile,removable and non-removable media implemented in any method ortechnology for storage of information, such as computer readableinstructions, data structures, program modules or other data. Systemmemory 104, removable storage 109 and non-removable storage 110 are allexamples of computer storage media. Computer storage media includes, butis not limited to, RAM, ROM, EEPROM, flash memory or other memorytechnology, CD-ROM, digital versatile disks (DVD) or other opticalstorage, magnetic cassettes, magnetic tape, magnetic disk storage orother magnetic storage devices, or any other medium which can be used tostore the desired information and which can be accessed by computingdevice 100. Any such computer storage media may be part of device 100.Computing device 100 may also have input device(s) 112 such as keyboard,mouse, pen, voice input device, touch input device, etc. Outputdevice(s) 114 such as a display, speakers, printer, etc. may also beincluded. All these devices are known in the art and need not bediscussed at length here.

Computing device 100 also contains communications connection(s) 116 thatallow the device to communicate with other computing devices 118, suchas over a network or a wireless mesh network. Communicationsconnection(s) 116 is an example of communication media. Communicationmedia typically embodies computer readable instructions, datastructures, program modules or other data in a modulated data signalsuch as a carrier wave or other transport mechanism and includes anyinformation delivery media. The term “modulated data signal” means asignal that has one or more of its characteristics set or changed insuch a manner as to encode information in the signal. By way of example,and not limitation, communication media includes wired media such as awired network or direct-wired connection, and wireless media such asacoustic, RF, infrared and other wireless media. The term computerreadable media as used herein includes both storage media andcommunication media.

In one embodiment, applications 106 further include recognition platform122, which is arranged to provide a binary persistence format for arecognition result data structure. In one embodiment, the data structuremay be a lattice structure that arranges recognition results in ahierarchical tree format that can be serialized. Recognition platform122 may employ or interact with other applications or modules such asink analysis application 124, recognition application 126, and parsingapplication 128. In another embodiment, one or more of theseapplications or modules may be independent from recognition platform 122or may even reside in other computing devices.

User input may be provided through a touch-sensitive display inputdevice (not shown), input device 112 or communication connection 116.The one or more databases may be stored in one of the storage devices ofcomputing device 100, or in a remote storage device (not shown). Diagramapplication 120 may provide an output, which is typically a binary fileor another file containing the generated recognition lattice to outputdevice 114, one of the storage devices, or to an external device, suchas a networked printer, through communication connection 116.

Illustrative Embodiments for Providing a Binary Persistence Format forRecognition Result Lattice

Embodiments of the present invention are related to a system and methodfor providing a binary persistence format to store recognition data in acompactable binary lattice structure.

Incremental analysis works well within a given session or instance of anink analysis object in an ink analysis application. An ink analysisapplication may not be able to perform incremental analysis after theink is persisted to disk. To perform the analysis after persistence to astorage medium requires saving large amounts of ink data along with apersisted form of the analysis results. With persistence of ink data,the analysis results may be loaded when the ink data is loaded andinjected into a new instance and accept any modifications as incrementalchanges to the existing state, rather than re-analyze everything.According to one aspect of the present invention, the saved data isseparated into manageable units.

Since the ink analysis information is separated into manageable units,developers may create more powerful features. As an example, a “tap toselect word” feature may be extended into “a tap once to select theword, tap twice to select the entire line and tap three times to selectthe entire paragraph” feature. By leveraging the tree structure returnedby the analysis operation, the developer may relate the tapped area backto a stroke in the tree. Once a stroke is found, a search may beperformed up the tree to determine how many neighboring strokes need tobe selected.

The structure provides many possibilities including use of differenttypes of hierarchical structures the parser may detect; ordered andunordered list, tables, shapes, flow charts, and even annotativecomments written inline with text. The types of features may vary fromapplication to application based on their needs and the available parseand recognition engines.

FIG. 2 illustrates a functional block diagram of example recognitionplatform 222 with a user and peripheral application. Example recognitionplatform 222 may be executed in a computing device such as computingdevice 100 of FIG. 1.

Recognition platform 222 may include functional blocks application logic232, ink analyzer 234, document model 236 and layout update 238. In anexample application, user 210 may create new data such as writing on atablet PC. Some applications may receive both ink data and non-ink data.

Application logic 232 may analyze the incoming data and update inkanalyzer 234 and document 236. In case of combined ink and non-data, itmay be essential to provide both to document model such that layoutupdate can render user 210 new data based on synchronized ink data andnon-ink data.

In one embodiment, ink analyzer 234 may receive the ink data and provideanalysis results to one or both of document model 236 and applicationlogic 232. In another embodiment, ink analyzer 232 may start abackground analysis operation 240, which may perform part of the inkanalysis based on predetermined parameters.

By rendering new data to user 210 recognition platform 222 enables user210 to interact with the analysis application. For example, new datarendered to user 210 may include a suggested top string based on theanalysis of the handwriting along with a predetermined number ofalternative strings each with a score or confidence index. If the topstring is not what user 210 intended to write, user 210 may select thecorrect string among the alternatives and continue writing.

In a further embodiment, the interaction with user 210 may enable user210 to annotate the ink, provide non-text input such as drawings, andthe like. All or portions of recognition platform 222 may reside on thesame machine or on separate machines that are arranged to communicatewith each other.

FIG. 3 illustrates example parsing of document 300 for a latticestructure according to another example embodiment. A recognitionplatform employing a binary persistence format such as recognitionplatform 122 of FIG. 1 may accept recognition results from a variety ofink analysis applications. Different ink analysis applications may takevarying approaches to text parsing. FIG. 3 shows examples of suchparsing techniques.

For most applications, a top level unit for text to be recognized isparagraph 302. Some applications perform ink analysis at the paragraphlevel, while others further parse the text. The top level unit paragraphis composed of lines such as lines 304 and 306. Some applicationsperform ink analysis at the line level.

Lines may be composed of words such as words 308-316. For someapplications, a word may be the unit level for performing ink analysis.Once an ink analysis application performs the analysis, it typicallygenerates data associated with the handwriting content such as strokes,suggested alternatives, metrics, and the like. Depending on the analysisapplication, such data may be generated on the paragraph level, linelevel, or word level. Each level of parsing may correspond to one ormore nodes in the tree structure. In one embodiment, the entire document300 may be represented in reference to a single root node. Any number ofnodes may be associated with any type of document as long as theyfacilitate the representation of the document in a document treestructure.

The recognition platform, according to one embodiment, is enabled toaccept any of these recognition results and save the associated data inan efficient format such that it can be used again. While an exampleparsing structure is illustrated in FIG. 3, the invention is not limitedto the shown structure. Other methods of parsing handwriting may beemployed in generating recognition results that may include additionalor fewer levels of parsing, non-text recognition (drawings), and thelike.

FIG. 4A is a diagram illustrating an example numbering of strokes ofhandwriting 400. As mentioned above, an ink analysis application mayapproach handwriting recognition at various levels. A basic level forhandwriting recognition may be number and type of strokes. For example,each word in handwriting 400 comprises letters. The ink analysisapplication may assign one or more stroke numbers to the letters, whichare later used to determine combinations of words, phrases etc.

In the example handwriting 400, first letter “t” is assigned two strokes(1 and 2). The letters “o”, “g”, and “e” following “t” are ach assignedone stroke (3, 4, and 5). This is followed by another “t” with twostrokes (6 and 7) and three single stroke letters “h”, “e”, and “r”(strokes 8, 9, 10).

The numbers assigned to the strokes may be used to determine an order ofthe strokes, to compute a score assigned to each alternative string, andto determine groups of letter combinations, which form columns of therecognition lattice as shown in the next figure.

FIG. 4B is a diagram illustrating example lattice columns 450 based onthe numbering of the strokes of FIG. 4A and possible combinationsincluding a top string and alternate strings according to an embodiment.

Columns 452, 456, and 460 represent alternative stroke combinationswithin the group of strokes recognized for the example word “together”in FIG. 4A. Columns 454 and 458 represent separators between thealternative stroke combinations. Columns 452, 456, and 460 may bedesignated by the numbering of the strokes that may be combined for eachparticular column. For example, column 452 may include any combinationof strokes between 1 and 10. Therefore, word combinations such as “to”,“toy”, and “together” are listed in column 452. Next alternativecombination column 456 includes combinations of strokes between strokenumbers 4 and 10. Example alternatives for this column are: “get”,“gather”, etc. It should be noted, that a recognition application mayreturn similar alternatives for words where the strokes may be alikesuch as “gether” and “gather.” Column 460 may include alternativecombinations for stroke numbers 8 through 10 such as “her”, “hey”, andthe like.

Once the alternative stroke combinations are determined, alternativestrings may be determined by assigning “next column” indices.Combinations of columns tied together by “next column” indices formalternative strings. For example, one alternative string in examplelattice columns 452 is “to get her” as shown on the top of the figure.

Alternative strings may be assigned scores based on stroke numbers andprioritized such that the application can present a user with a topstring and one or more alternatives to choose from. On the other hand, aprioritization system strictly based on scores calculated from strokesmay return a high number of illogical alternatives. As described inconjunction with the next figure, a recognition result lattice accordingto one embodiment may enable the recognition platform to assignadditional parameters such a confidence parameter that may be based onother selection criteria than stroke score, and suggest alternativestrings based on the confidence parameter.

FIG. 5 is a diagram illustrating example recognition lattice 500structured according to one embodiment of binary persistence format.Recognition lattice 500 is an example embodiment for storing a documentstructure in serialized binary format. Even though an ink documentstructure is referenced herein, recognition lattice 500 in serial binaryformat may be used to store any type of tree document structure. Whenrecognition lattice 500 is generated, one ore more strings exist thatrelate to the document structure.

In one embodiment, recognition lattice 500 may be compressed forresource efficiency. The compression may include a Lempel-Ziv Welchformat (“LZW format”) of the strings. In another embodiment, thecompression may include at least one of a ZIP algorithm, a ComitéConsultatif International Téléphonique et Télégraphique (CCITT)algorithm, a Run Length Encoding (RLE) algorithm, or any othercompression format that reduces the size of the strings. In a furtherembodiment, storage includes Multi-Bit Encoding (“MBE”) values, whichfacilitate the storage of unsigned integers to save storage space.

Recognition lattice 500 includes a first data field reserved for latticeinformation. The lattice data in first data field 502 may start withsize information about the lattice followed by a byte mask calledlattice descriptor. The lattice descriptor is a set of flags that may bedefined in one embodiment as follows:

LeftSeparator //Indicates the presence of a left separatorRightSeparator // Indicates the presence of right separator Column  //Indicates lattice contains single column Columns  // Indicates latticecontains multiple columns. Default  // Indicates an empty lattice

Information may be stored in a specified format in a data stream and thesequence of data in the persisted stream is governed by the flags in thelattice descriptor. A lattice may or may not have column information. Ifit also does not have left and right separator, the serialized size ofthe lattice data is 0. As indicated above, one or more of the above datamay include MBE.

If the lattice descriptor indicates presence of a left and/or rightseparator, the descriptor is followed by data indicating theseparator(s). Similarly, if the lattice descriptor indicates multiplecolumns, the separator(s) are followed by a column count. In case of oneor more columns, the column count in first data field 502 is followed bysecond data field(s) (e.g. 504, 506). First data field 502 ends withdata associated with lattice properties.

A structure of second data field 504 is similar to the structure offirst data field 502. Second data field 504 includes data about a firstcolumn in the lattice. If the lattice includes multiple columns, seconddata field is followed by similarly structured data fields (e.g. 506)representing further columns.

Second data field 502 begins with size information about the firstcolumn. Column size information is followed by a column descriptor,which is a collection of flags describing the lattice columnrepresentation inside the persisted stream. In one embodiment, thecolumn descriptor may be defined as:

StrokeIds       // Indicates the presence of stroke id collectionStrokeId      // Indicates the presence of 1 stroke idStrokeIdContiguous // Indicates multiple stroke ids in sequence.TopAlternateElement // Indicates presence of top alternateElement      // Indicates the presence of single elementElements      // Indicates the presence of multiple elementsRecognitionPropertyConfidenceLevel // Indicates confidence dataRecognitionPropertyLineMetrics  // Indicates line metrics dataMoreRecognitionProperties    // More recognition propertiesDefault          // Indicates a default lattice column

The lattice column descriptor not only defines the presence of differentcomponents of the lattice column, but it also specifies the order inwhich they appear in the serialized stream.

If the StrokeIds flag is present in the descriptor, it implies that thefirst data in the stream is a count of stroke ids (stroke numbers) andthe stroke Ids themselves.

If the StrokeId flag is present in the descriptor, it implies that thefirst data in the stream is a value of the stroke id itself and there isonly one stroke for this column.

If the StrokeIdContiguous flag is present in the descriptor, it mayimply that here are multiple strokes for this column and the stroke idsare in sequence and are incremented by 1. In that case, the count ofstrokes may be written first for this column followed by the first id.The subsequent stroke ids may be obtained by adding one to the previousid.

If the TopAlternateElement flag is set in the descriptor, it implies thecurrent location of the stream holds a value of the index into the listof elements that is the top alternate element.

If the Element flag is set, it implies only one element in the column.On the other hand, if the Elements flag is set, it implies more than oneelement in the column. In that case, first a count of elements is placedin the current position in the stream. This is followed by third datafield(s) (e.g. 508, 510).

Third data field(s) are followed by column property information such asRecognitionPropertyConfidenceLevel. If this flag is set, it implies thepresence of known recognition property confidence level in the stream.Confidence level may be a signed multi byte encoded integer.

If the RecognitionPropertyLineMetrics flag is set, it implies thepresence of known line metrics in the stream. Line metrics is a propertyassociated with alignment of lines of text and may include informationsuch as baseline coordinates, midline offset, etc.

In one embodiment, second data field 504 may include additional propertyinformation associated with the column. If MoreRecognitionPropertiesflag is set, it implies both known and custom properties in the stream.These properties may include information such as boldness, linenumbering, and other application-specified properties.

Third data field 508 following element count in second data field 504includes information associated with element(s) of the column and isstructured in a similar way to second data field 504. If there aremultiple elements within the column, third data field 508 is followed byadditional third data field(s) (e.g. 510). Similar to second data field504, third data field 508 begins with size information about the elementdata. Element data size information is followed by an elementdescriptor, which is a collection of flags describing the latticeelement representation inside the persisted stream. In one embodiment,the element descriptor may be defined as:

NextColumn    // Indicates presence of next column index Score    //Indicates presence of non-zero Score StrokeCount    // Indicatespresence of stroke Count DataString    // Indicates the presence of datastring RecognitionPropertyConfidenceLevel // Indicates presence of  recognition confidence data RecognitionPropertyLineMetrics //Indicates line metrics data MoreRecognitionProperties // Indicate morerecognition   properties Default //Indicates a default lattice column

The lattice element descriptor not only defines the presence ofdifferent components of the lattice element, but it also specifies theorder in which they appear in the serialized stream.

If the NextColumn flag is present in the descriptor, it implies that thefirst data in the stream is a value of next column index for thiselement.

If the Score flag is set in the descriptor, it implies the currentlocation of the stream holds a value of the non-zero score for theelement.

If the StrokeCount flag is set, it implies a value of the non-zerostroke count associated with the element.

If the DataString flag is set, it implies the string data associatedwith this element is inside the stream and may be loaded from thecurrent position.

If the RecognitionPropertyConfidenceLevel flag is set, it implies thepresence of known confidence level in the stream. Confidence level maybe a signed multi byte encoded integer.

If the RecognitionPropertyLineMetrics flag is set, it implies thepresence of known line metrics in the stream.

If the MoreRecognitionProperties flag is set, it implies both known andcustom properties in the stream. The known recognition properties may bewritten after the element data have been written into the stream. If theelement has any other known (apart from confidence level and linemetrics) or custom recognition property, it may be saved at thisposition in the stream.

Similar to first data field 502, some or all of the data in the seconddata fields and the third data fields may include MBE. The specificflags and data types described above are for illustrative purposes andthe present invention may be implemented with fewer or additional flagand data types. Moreover, fewer or additional data fields may be defineddepending on a structure of recognition lattice 500.

FIG. 6 is a logic flow diagram illustrating a process for storingrecognition data in a lattice. Process 600 may be performed byrecognition platform 122 of FIG. 1. Process 600 begins at block 602,where an ink document is generated. Generating the ink document mayinclude employing a digitizer for digitizing stroke inputs from a user.The digitizer may include a computing device (e.g. computing device 100of FIG. 1), a mobile computing device, a tablet PC, or any device thatfacilitates the operation of a recognition application. Moreover,process 600 may be implemented in relation to any type of data. Forexample, the present invention may also be used in association with aword processing application, spreadsheet application, drawingapplication, graphics application, notes application, pictureapplication, and the like. Processing moves to block 604 next.

At block 604, raw ink data is generated. In one embodiment, generatingraw ink data includes a digitizer converting stroke inputs into raw inkdata and storing the raw ink data to a raw data storage, transmittingthe raw ink data to an application, and the like. Processing advances todecision block 606 next.

At block decision 606, a determination is made whether an external inkanalyzer is to be used or not. If an external analyzer is to be used,processing moves to block 610. If the ink analysis application isintegrated into the recognition platform, processing flows to block 608.

At block 608, recognition data is generated. As described previously,generating recognition data may involve a variety of approaches inparsing the handwriting at paragraph level, line level, and word level.In addition to recognizing text, an analysis application may furtherrecognize drawings, tables, and other non-text entries. Furthermore,recognition may involve annotations on already recognized handwriting.In one embodiment, recognition may be an iterative process, where theuser is provided choices among alternative strings and the processcontinued based on the user's selection. Processing proceeds from block608 to block 612.

At block 610, recognition data is received from the external analyzer.The external analyzer may be a separate application residing on the samecomputing device, on a second computing device that is coupled to thefirst computing device running the recognition platform through anetwork, a direct link, and the like. Processing then moves to block612.

At block 612 a document structure (e.g. a recognition lattice) isgenerated based on the received data. The document structure may begenerated as described above in accordance with FIG. 5. The documentstructure may include a hierarchical tree structure with a plurality ofnodes that correlate to inking. For example, the document structure mayinclude a lattice node, one or more column nodes under the lattice node,and one or more element nodes under each column node. These nodes maycorrelate to a tree structure comprising one or more paragraph nodes,line nodes, word nodes and stroke nodes.

Each node may include information associated with content, properties,and relations of that node to other nodes. In another embodiment, theink document structure may also include a drawing node and/or a hintnode. It is contemplated that the ink document structure may include anytype of node that facilitates a binary tree representation of theinking. Processing advances to block 614 from block 612.

At block 614, the recognition may be stored for global accessibility. Inone embodiment, the lattice structure may be compressed and stored asset forth above in conjunction with FIG. 5. In such a case, inking maybe generated in conjunction with an application and then stored foraccessibility to other applications. Stated another way, otherapplications associated with the platform may utilize the ink documentstructure and the raw ink to regenerate the analyzed ink. Thisaccessibility facilitates cut and paste operations between applications.Also, the ink may be modified without requiring reanalysis of the entireink document inasmuch as the ink has been parsed, recognized and savedin a serialized format. After block 614, processing proceeds to acalling process for further actions.

The blocks included in process 600 are for illustration purposes. Arecognition lattice with binary persistence format may be implemented bya similar process with fewer or additional steps including customizationof hierarchical levels and contents of each level.

The above specification, examples and data provide a completedescription of the manufacture and use of the composition of theinvention. Since many embodiments of the invention can be made withoutdeparting from the spirit and scope of the invention, the inventionresides in the claims hereinafter appended.

1. A computer-implemented method for storing ink recognition data, themethod comprising: parsing an electronic ink document to generate ahierarchy having a plurality of hierarchical nodes; generating arecognition lattice that correlates to at least one node of thehierarchy generated from the parsing of the electronic ink document,wherein generating the recognition lattice includes generating a latticeinformation field, wherein generating the lattice information fieldincludes: generating a lattice descriptor field, wherein the latticedescriptor field includes a plurality of settable flag fields, whereinat least one of the settable flag fields includes a settable column flagfield, determining whether a column flag is set within the settablecolumn flag field of the lattice descriptor field, when the column flagfield of the lattice descriptor is set with a column flag, generating acolumn count field, in the lattice descriptor field, that indicates acount of columns of the lattice, latticing a column recognition field,into the column count field, for each column indicated by the count ofcolumns of the lattice, wherein each column recognition field for eachcolumn indicated by the count of columns of the lattice includes columnproperties of a respective column; and persisting the generatedrecognition lattice in a binary format to facilitate the regeneration ofthe electronic ink document from the binary persistence of therecognition lattice.
 2. The computer-implemented method of claim 1,wherein the settable column flag field is a settable single column flagfield.
 3. The computer-implemented method of claim 1, wherein thesettable column flag field is a settable multiple column flag field. 4.The computer-implemented method of claim 1, wherein at least one of thesettable flag fields is a left separator flag field.
 5. Thecomputer-implemented method of claim 4, wherein at least one of thesettable flag fields is a right separator flag field.
 6. Thecomputer-implemented method of claim 5, further comprising a generatinga lattice size field, wherein the lattice size field stores anidentifier that indicates the size of the recognition lattice.
 7. Thecomputer-implemented method of claim 6, further comprising setting thelattice size field to null when the column flag field of the latticedescriptor is not set with a column flag, when a left separator flag isnot set in the left separator flag field and when a right separator flagis not set in the right separator flag field.
 8. A computer-readablestorage medium on a memory having computer-executable instructions forstoring ink recognition data, the instructions comprising: generating arecognition lattice that correlates to at least one node of thehierarchy generated from a parsed electronic ink document, whereingenerating the recognition lattice includes generating a latticeinformation field, wherein generating the lattice information fieldincludes: generating a lattice descriptor field, wherein the latticedescriptor field includes a plurality of settable flag fields, whereinat least one of the settable flag fields includes a settable column flagfield, determining whether a column flag is set within the settablecolumn flag field of the lattice descriptor field, when the column flagfield of the lattice descriptor is set with a column flag, generating acolumn count field, in the lattice descriptor field, that indicates acount of columns of the lattice, latticing a column recognition field,into the column count field, for each column indicated by the count ofcolumns of the lattice, wherein each column recognition field for eachcolumn indicated by the count of columns of the lattice includes columnproperties of a respective column; and persisting the generatedrecognition lattice in a binary format to facilitate the regeneration ofthe electronic ink document from the binary persistence of therecognition lattice.
 9. The computer-readable storage medium of claim 8,wherein the settable column flag field is at least one member of a groupcomprising: a settable single column flag field, and a settable multiplecolumn flag field.
 10. The computer-readable storage medium of claim 8,wherein at least one of the settable flag fields is a left separatorflag field.
 11. The computer-readable storage medium of claim 10,wherein at least one of the settable flag fields is a right separatorflag field.
 12. The computer-readable storage medium of claim 11,further comprising a generating a lattice size field, wherein thelattice size field stores an identifier that indicates the size of therecognition lattice.
 13. The computer-readable storage medium of claim12, further comprising setting the lattice size field to null when thecolumn flag field of the lattice descriptor is not set with a columnflag, when a left separator flag is not set in the left separator flagfield and when a right separator flag is not set in the right separatorflag field.
 14. A system for storing ink recognition data, the systemcomprising: a processor; and a memory having computer-executableinstructions stored thereon, wherein the computer-executableinstructions are configured for: generating a recognition lattice thatcorrelates to at least one node of the hierarchy generated from anelectronic ink document, wherein generating the recognition latticeincludes generating a lattice information field, wherein generating thelattice information field includes: generating a lattice descriptorfield, wherein the lattice descriptor field includes a plurality ofsettable flag fields, wherein at least one of the settable flag fieldsincludes a settable column flag field, determining whether a column flagis set within the settable column flag field of the lattice descriptorfield, when the column flag field of the lattice descriptor is set witha column flag, generating a column count field, in the latticedescriptor field, that indicates a count of columns of the lattice,latticing a column recognition field, into the column count field, foreach column indicated by the count of columns of the lattice, whereineach column recognition field for each column indicated by the count ofcolumns of the lattice includes column properties of a respectivecolumn; and persisting the generated recognition lattice in a binaryformat to facilitate the regeneration of the electronic ink documentfrom the binary persistence of the recognition lattice.
 15. The systemof claim 14, wherein the settable column flag field is a settable singlecolumn flag field.
 16. The system of claim 14, wherein the settablecolumn flag field is a settable multiple column flag field.
 17. Thesystem of claim 14, wherein at least one of the settable flag fields isa left separator flag field.
 18. The system of claim 17, wherein atleast one of the settable flag fields is a right separator flag field.19. The system of claim 18, further comprising a generating a latticesize field, wherein the lattice size field stores an identifier thatindicates the size of the recognition lattice.
 20. The system of claim19, further comprising setting the lattice size field to null when thecolumn flag field of the lattice descriptor is not set with a columnflag, when a left separator flag is not set in the left separator flagfield and when a right separator flag is not set in the right separatorflag field.